home *** CD-ROM | disk | FTP | other *** search
/ NetNews Offline 2 / NetNews Offline Volume 2.iso / news / comp / lang / c++-part1 / 631 < prev    next >
Encoding:
Internet Message Format  |  1996-08-06  |  4.1 KB
  1. Path: news.th-darmstadt.de!news
  2. From: Enno Sandner <enno@intellektik.informatik.th-darmstadt.de>
  3. Newsgroups: comp.lang.c++,comp.sys.mac.programmer.codewarrior,comp.sys.mac.oop
  4. Subject: Re: Help needed with Runtime Type Info
  5. Date: Fri, 05 Jan 1996 15:06:33 +0100
  6. Organization: Fachbereich Informatik, TH Darmstadt
  7. Message-ID: <30ED3069.15FB7483@intellektik.informatik.th-darmstadt.de>
  8. References: <pcal-0401962039480001@slip-d8.rdrop.com>
  9. NNTP-Posting-Host: kitz.intellektik.informatik.th-darmstadt.de
  10. Mime-Version: 1.0
  11. Content-Type: text/plain; charset=us-ascii
  12. Content-Transfer-Encoding: 7bit
  13. X-Mailer: Mozilla 2.0b4 (X11; I; SunOS 4.1.3 sun4m)
  14.  
  15. Patrick Calahan wrote:
  16. > 
  17. >      I need a little assistance from a C++ guru.
  18. > 
  19. >      I have an abstract class B from which D,E and F are derived
  20. > 
  21. >      I also have an abstract class O from which P, Q and R are derived.
  22. > 
  23. >      Objects derived from O need to perform specific operations given a
  24. >      pair of pointers to B's. The operation to be performed depends on
  25. >      precisely  what kind of B's are given to the O.
  26. > 
  27. >      I thought that by simply overloading member function f in the O's,
  28. >      I could achieve this affect nicely - f(D*,D*), f(D*,E*), f(E*,F*)...
  29. >      could be defined to handle the particualr pair-cases appropriately.
  30. >      A member function in O f(B*,B*) would handle all cases not handled
  31. >      specifically by the subclasses.
  32. > 
  33. >      The only problem is figuring out exactly what type of object a B* is
  34. >      pointing to so that the appropriate call to O.f can be made.  I.e.,
  35. >      given a pointer to a B, I need to cast it to a D*,E*, or F*.
  36. > 
  37. >      On page 640 of Stroustrup, he says that [in dynamic_cast<t>(v)]
  38. >      "If T is void* then v must be a pointer, and the result value is a
  39. >      pointer to the complete object pointed to by v."
  40. > 
  41. >      So, if I read him correctly,
  42. > 
  43. >      dynamic_cast<void*>(p*)
  44. > 
  45. >      should cast p to a pointer to an object of the most complete type of
  46. >      the object pointed to by p, i.e. cast my B* to an D*, E* or F*.
  47. >      This sounds like what I want.
  48. > 
  49. >      Unfortunately, if I try to compile the following using MetroWerks
  50. >      CodeWarrior 7 (I do have RTTI enabled):
  51. > 
  52. > 
  53. >      some_function(B* b1, B*b2, O* o)
  54. >      {
  55. > 
  56. >      // here I need to figure out what types of objects b1 & b2 really are
  57. >      // and cast the pointers so the correct version of f will be called.
  58. > 
  59. >      o->f( dynamic_cast<void*>(b1), dynamic_cast<void*>(b2) );
  60. > 
  61. >      }
  62. > 
  63. > 
  64. >      b1 and b2 apparently get cast to void*; the compiler returns that
  65. >       f(void*,void*) can't be found.
  66. > 
  67. >      What do I need to do here?
  68. > 
  69. > 
  70. >      I'm relatively new to C++, so I might just be looking at the problem
  71. >      incorrectly.
  72. > 
  73. >      I tried to do it just using virtual functions in B, but the fact that
  74. >      I'm dealing with pairs of B's in the O's seems to make this less
  75. >      elegant.
  76. > 
  77. >      Moreover, it makes more sense in my application for O to be a separate
  78. >      class.
  79. > 
  80. >      Many many thanks in advance for any help,
  81.  
  82. Overloaded functions are selected according to the static type of the
  83. arguments. This allows to resolve such calls at compile-time.
  84. Because void-pointers aren't silently converted to any other type the
  85. compiler looks for a function 'O :: f(void*,void*)' which doesn't
  86. exists. 
  87. To use the 'dynamic_cast' you need to narrow the pointers to the desired 
  88. type. For example to narrow a B-pointer to a D-pointer you could write:
  89.  
  90.         void f(B* b) { D* d=dynamic_cast<D*>(b); }
  91.  
  92. If 'b' isn't of type D (or a subclass of D) 'd' will become zero,
  93. otherwise 
  94. 'd' will point to the appropriate D-object. However this solution will
  95. lead
  96. to some code like 'hardcode the possible type and verify the result at
  97. run-time' (ie. sth. similar to a switch-construct). This should clarify
  98. that 
  99. the dynamic-cast will not be very useful to solve your problem.
  100. What you really need is some sort of double-dispatching. You could for
  101. example build up a map where the elements are functor-objects and the
  102. keys
  103. are pairs of typeid's. In this way you can maintain arbitary behavior
  104. connected
  105. to a pair of typeid's. This solution can easily be extended to more then
  106. two
  107. arguments.
  108.  
  109.     Enno
  110.